package backtesting

import (
	"errors"
	"fmt"
	"time"
)

type DirectionType string

const (
	Buy  DirectionType = "buy"
	Sell DirectionType = "sell"
)

type TradeRecord struct {
	Date       time.Time     // 交易时间
	Price      float64       // 交易金额
	Volume     int           // 交易数量
	Direction  DirectionType // 交易方向
	Commission float64       // 交易手续费
}

type Data struct {
	MaxAmount       float64 // 最大本金, 不设置，则默认不限制
	SingleMaxAmount float64 // 单笔金额, 金额/数量一定要有一个大于0的
	SingleMaxVolume int     // 单笔交易数量

	Amount      float64 // 总金额
	Position    int     // 持仓
	MarketValue float64 // 市值
	Profit      float64 // 盈亏

	TradeRecords []TradeRecord // 交易记录

	err   chan error       // 错误通道
	trade chan TradeRecord // 交易通道
}

func New() *Data {
	return &Data{
		err:   make(chan error),
		trade: make(chan TradeRecord)}
}

// Buy 买入
func (d *Data) Buy(price float64, volume int) {
	d.Position += volume

	amount := price * float64(volume)
	if d.SingleMaxAmount > 0 && amount > d.SingleMaxAmount {
		d.err <- errors.New("单笔交易金额超过限制")
		return
	}

	if d.MaxAmount > 0 && d.Amount+amount > d.MaxAmount {
		d.err <- errors.New("总金额超过限制")
	}

	if d.SingleMaxVolume > 0 && volume > d.SingleMaxVolume {
		d.err <- errors.New("单笔交易数量超过限制")
	}

}

// Sell 卖出
func (d *Data) Sell(price float64, volume int) {}

// Run 运行, 接收交易记录并处理
func (d *Data) Run() {
	// 初始化
	if d.err == nil {
		d.err = make(chan error)
	}
	if d.trade == nil {
		d.trade = make(chan TradeRecord)
	}

	go func() {
		for {
			select {
			case err := <-d.err:
				fmt.Println(err)
			case tradeRecord := <-d.trade: // 处理交易记录
				if tradeRecord.Direction == Buy {
					d.Buy(tradeRecord.Price, tradeRecord.Volume)
				} else if tradeRecord.Direction == Sell {
					d.Sell(tradeRecord.Price, tradeRecord.Volume)
				}
			}
		}
	}()
}
